juce/source/extras/the jucer/src/model/paintelements/jucer_PaintElementImage.h

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #ifndef __JUCER_PAINTELEMENTIMAGE_JUCEHEADER__
  27 #define __JUCER_PAINTELEMENTIMAGE_JUCEHEADER__
  28
  29 #include "../jucer_PaintRoutine.h"
  30 #include "../../properties/jucer_FilePropertyComponent.h"
  31 #include "jucer_ImageResourceProperty.h"
  32 #include "jucer_PaintElementUndoableAction.h"
  33
  34
  35 //==============================================================================
  36 /**
  37 */
  38 class PaintElementImage   : public PaintElement
  39 {
  40 public:
  41     enum StretchMode
  42     {
  43         stretched = 0,
  44         proportional = 1,
  45         proportionalReducingOnly = 2
  46     };
  47
  48     //==============================================================================
  49     PaintElementImage (PaintRoutine* owner)
  50         : PaintElement (owner, "Image"),
  51           opacity (1.0),
  52           mode (stretched)
  53     {
  54     }
  55
  56     ~PaintElementImage()
  57     {
  58     }
  59
  60     //==============================================================================
  61     const Drawable* getDrawable()
  62     {
  63         JucerDocument* const document = getDocument();
  64
  65         if (document != 0)
  66             return document->getResources().getDrawable (resourceName);
  67
  68         return 0;
  69     }
  70
  71     void draw (Graphics& g, const ComponentLayout* layout, const Rectangle<int>& parentArea)
  72     {
  73         const Rectangle<int> r (position.getRectangle (parentArea, layout));
  74
  75         const Drawable* const image = getDrawable();
  76
  77         if (image != 0)
  78         {
  79             image->drawWithin (g, r.toFloat(),
  80                                mode == stretched ? RectanglePlacement::stretchToFit
  81                                                  : (mode == proportionalReducingOnly ? (RectanglePlacement::centred | RectanglePlacement::onlyReduceInSize)
  82                                                                                      : RectanglePlacement::centred),
  83                                (float) opacity);
  84         }
  85         else
  86         {
  87             g.setColour (Colours::grey.withAlpha (0.5f));
  88             g.fillRect (r);
  89
  90             g.setColour (Colours::black);
  91             g.drawText ("(image missing)",
  92                         r.getX(), r.getY(), r.getWidth(), r.getHeight(),
  93                         Justification::centred, true);
  94         }
  95     }
  96
  97     //==============================================================================
  98     void getEditableProperties (Array <PropertyComponent*>& properties)
  99     {
 100         PaintElement::getEditableProperties (properties);
 101
 102         properties.add (new ImageElementResourceProperty (this));
 103         properties.add (new StretchModeProperty (this));
 104         properties.add (new OpacityProperty (this));
 105         properties.add (new ResetSizeProperty (this));
 106     }
 107
 108     void fillInGeneratedCode (GeneratedCode& code, String& paintMethodCode)
 109     {
 110         String r;
 111
 112         if (opacity > 0)
 113         {
 114             if (dynamic_cast <const DrawableImage*> (getDrawable()) != 0)
 115             {
 116                 const String imageVariable ("cachedImage_" + resourceName);
 117
 118                 code.addImageResourceLoader (imageVariable, resourceName);
 119
 120                 if (opacity >= 254.0 / 255.0)
 121                     r << "g.setColour (Colours::black);\n";
 122                 else
 123                     r << "g.setColour (Colours::black.withAlpha (" << valueToFloat (opacity) << "));\n";
 124
 125                 String x, y, w, h;
 126                 positionToCode (position, getDocument()->getComponentLayout(), x, y, w, h);
 127
 128                 if (mode == stretched)
 129                 {
 130                     r << "g.drawImage (" << imageVariable << ",\n             "
 131                       << x << ", " << y << ", " << w << ", " << h
 132                       << ",\n             0, 0, "
 133                       << imageVariable << ".getWidth(), "
 134                       << imageVariable << ".getHeight());\n\n";
 135                 }
 136                 else
 137                 {
 138                     r << "g.drawImageWithin (" << imageVariable << ",\n                   "
 139                       << x << ", " << y << ", " << w << ", " << h
 140                       << ",\n                   ";
 141
 142                     if (mode == proportionalReducingOnly)
 143                         r << "RectanglePlacement::centred | RectanglePlacement::onlyReduceInSize";
 144                     else
 145                         r << "RectanglePlacement::centred";
 146
 147                     r << ",\n                   false);\n\n";
 148                 }
 149
 150                 paintMethodCode += r;
 151             }
 152             else
 153             {
 154                 if (resourceName.isNotEmpty())
 155                 {
 156                     const String imageVariable (L"drawable" + String (code.getUniqueSuffix()));
 157
 158                     code.privateMemberDeclarations
 159                         << "Drawable* " << imageVariable << ";\n";
 160
 161                     code.constructorCode
 162                         << imageVariable << " = Drawable::createFromImageData ("
 163                         << resourceName << ", " << resourceName << "Size);\n";
 164
 165                     code.destructorCode
 166                         << "deleteAndZero (" << imageVariable << ");\n";
 167
 168                     if (opacity >= 254.0 / 255.0)
 169                         r << "g.setColour (Colours::black);\n";
 170                     else
 171                         r << "g.setColour (Colours::black.withAlpha (" << valueToFloat (opacity) << "));\n";
 172
 173                     String x, y, w, h;
 174                     positionToCode (position, code.document->getComponentLayout(), x, y, w, h);
 175
 176                     r << "jassert (" << imageVariable << " != 0);\n"
 177                       << "if (" << imageVariable << " != 0)\n    "
 178                       << imageVariable  << "->drawWithin (g, "
 179                       << x << ", " << y << ", " << w << ", " << h
 180                       << ",\n"
 181                       << String::repeatedString (" ", imageVariable.length() + 18)
 182                       << (mode == stretched ? "RectanglePlacement::stretchToFit"
 183                                             : (mode == proportionalReducingOnly ? "RectanglePlacement::centred | RectanglePlacement::onlyReduceInSize"
 184                                                                                 : "RectanglePlacement::centred"))
 185                       << ", " << valueToFloat (opacity)
 186                       << ");\n\n";
 187
 188                     paintMethodCode += r;
 189                 }
 190                 else
 191                 {
 192                     jassertfalse // this resource isn't valid!
 193                 }
 194             }
 195         }
 196     }
 197
 198     //==============================================================================
 199     class SetResourceAction   : public PaintElementUndoableAction <PaintElementImage>
 200     {
 201     public:
 202         SetResourceAction (PaintElementImage* const element, const String& newResource_)
 203             : PaintElementUndoableAction <PaintElementImage> (element),
 204               newResource (newResource_)
 205         {
 206             oldResource = element->getResource();
 207         }
 208
 209         bool perform()
 210         {
 211             showCorrectTab();
 212             getElement()->setResource (newResource, false);
 213             return true;
 214         }
 215
 216         bool undo()
 217         {
 218             showCorrectTab();
 219             getElement()->setResource (oldResource, false);
 220             return true;
 221         }
 222
 223     private:
 224         String newResource, oldResource;
 225     };
 226
 227     void setResource (const String& newName, const bool undoable)
 228     {
 229         if (resourceName != newName)
 230         {
 231             if (undoable)
 232             {
 233                 perform (new SetResourceAction (this, newName),
 234                          "Change image resource");
 235             }
 236             else
 237             {
 238                 resourceName = newName;
 239                 changed();
 240             }
 241         }
 242
 243         repaint();
 244     }
 245
 246     const String getResource() const
 247     {
 248         return resourceName;
 249     }
 250
 251     //==============================================================================
 252     class SetOpacityAction   : public PaintElementUndoableAction <PaintElementImage>
 253     {
 254     public:
 255         SetOpacityAction (PaintElementImage* const element, const double newOpacity_)
 256             : PaintElementUndoableAction <PaintElementImage> (element),
 257               newOpacity (newOpacity_)
 258         {
 259             oldOpacity = element->getOpacity();
 260         }
 261
 262         bool perform()
 263         {
 264             showCorrectTab();
 265             getElement()->setOpacity (newOpacity, false);
 266             return true;
 267         }
 268
 269         bool undo()
 270         {
 271             showCorrectTab();
 272             getElement()->setOpacity (oldOpacity, false);
 273             return true;
 274         }
 275
 276     private:
 277         double newOpacity, oldOpacity;
 278     };
 279
 280     void setOpacity (double newOpacity, const bool undoable)
 281     {
 282         newOpacity = jlimit (0.0, 1.0, newOpacity);
 283
 284         if (opacity != newOpacity)
 285         {
 286             if (undoable)
 287             {
 288                 perform (new SetOpacityAction (this, newOpacity),
 289                          "Change image opacity");
 290             }
 291             else
 292             {
 293                 opacity = newOpacity;
 294                 changed();
 295             }
 296         }
 297     }
 298
 299     double getOpacity() const throw()               { return opacity; }
 300
 301     //==============================================================================
 302     static const char* getTagName() throw()         { return "IMAGE"; }
 303
 304     void resetToImageSize()
 305     {
 306         const Drawable* const image = getDrawable();
 307
 308         if (image != 0 && getParentComponent() != 0)
 309         {
 310             const Rectangle<int> parentArea (((PaintRoutineEditor*) getParentComponent())->getComponentArea());
 311
 312             Rectangle<int> r (getCurrentBounds (parentArea));
 313             Rectangle<float> bounds (image->getDrawableBounds());
 314
 315             r.setSize ((int) (bounds.getWidth() + 0.999f), (int) (bounds.getHeight() + 0.999f));
 316
 317             setCurrentBounds (r, parentArea, true);
 318         }
 319     }
 320
 321     //==============================================================================
 322     class SetStretchModeAction  : public PaintElementUndoableAction <PaintElementImage>
 323     {
 324     public:
 325         SetStretchModeAction (PaintElementImage* const element, const StretchMode newValue_)
 326             : PaintElementUndoableAction <PaintElementImage> (element),
 327               newValue (newValue_)
 328         {
 329             oldValue = element->getStretchMode();
 330         }
 331
 332         bool perform()
 333         {
 334             showCorrectTab();
 335             getElement()->setStretchMode (newValue, false);
 336             return true;
 337         }
 338
 339         bool undo()
 340         {
 341             showCorrectTab();
 342             getElement()->setStretchMode (oldValue, false);
 343             return true;
 344         }
 345
 346     private:
 347         StretchMode newValue, oldValue;
 348     };
 349
 350     StretchMode getStretchMode() const throw()                        { return mode; }
 351
 352     void setStretchMode (const StretchMode newMode, const bool undoable)
 353     {
 354         if (mode != newMode)
 355         {
 356             if (undoable)
 357             {
 358                 perform (new SetStretchModeAction (this, newMode),
 359                          "Change image mode");
 360             }
 361             else
 362             {
 363                 mode = newMode;
 364                 changed();
 365             }
 366         }
 367     }
 368
 369     //==============================================================================
 370     XmlElement* createXml() const
 371     {
 372         XmlElement* e = new XmlElement (getTagName());
 373         position.applyToXml (*e);
 374         e->setAttribute ("resource", resourceName);
 375         e->setAttribute ("opacity", opacity);
 376         e->setAttribute ("mode", (int) mode);
 377
 378         return e;
 379     }
 380
 381     bool loadFromXml (const XmlElement& xml)
 382     {
 383         if (xml.hasTagName (getTagName()))
 384         {
 385             position.restoreFromXml (xml, position);
 386             resourceName = xml.getStringAttribute ("resource", String::empty);
 387             opacity = xml.getDoubleAttribute ("opacity", 1.0);
 388             mode = (StretchMode) xml.getIntAttribute ("mode", (int) stretched);
 389
 390             repaint();
 391             return true;
 392         }
 393         else
 394         {
 395             jassertfalse
 396             return false;
 397         }
 398     }
 399
 400 private:
 401     String resourceName;
 402     double opacity;
 403     StretchMode mode;
 404
 405     //==============================================================================
 406     class ImageElementResourceProperty    : public ImageResourceProperty <PaintElementImage>
 407     {
 408     public:
 409         ImageElementResourceProperty (PaintElementImage* const element_)
 410             : ImageResourceProperty <PaintElementImage> (element_, "image source")
 411         {
 412         }
 413
 414         //==============================================================================
 415         void setResource (const String& newName)
 416         {
 417             element->setResource (newName, true);
 418         }
 419
 420         const String getResource() const
 421         {
 422             return element->getResource();
 423         }
 424     };
 425
 426     //==============================================================================
 427     class OpacityProperty  : public SliderPropertyComponent,
 428                              private ChangeListener
 429     {
 430     public:
 431         OpacityProperty (PaintElementImage* const element_)
 432             : SliderPropertyComponent ("opacity", 0.0, 1.0, 0.001),
 433               element (element_)
 434         {
 435             element->getDocument()->addChangeListener (this);
 436         }
 437
 438         ~OpacityProperty()
 439         {
 440             element->getDocument()->removeChangeListener (this);
 441         }
 442
 443         void setValue (double newValue)
 444         {
 445             element->getDocument()->getUndoManager().undoCurrentTransactionOnly();
 446
 447             element->setOpacity (newValue, true);
 448         }
 449
 450         double getValue() const
 451         {
 452             return element->getOpacity();
 453         }
 454
 455         void changeListenerCallback (ChangeBroadcaster*)
 456         {
 457             refresh();
 458         }
 459
 460     private:
 461         PaintElementImage* const element;
 462     };
 463
 464     class StretchModeProperty  : public ChoicePropertyComponent,
 465                                  private ChangeListener
 466     {
 467     public:
 468         StretchModeProperty (PaintElementImage* const element_)
 469             : ChoicePropertyComponent ("stretch mode"),
 470               element (element_)
 471         {
 472             choices.add ("Stretched to fit");
 473             choices.add ("Maintain aspect ratio");
 474             choices.add ("Maintain aspect ratio, only reduce in size");
 475
 476             element->getDocument()->addChangeListener (this);
 477         }
 478
 479         ~StretchModeProperty()
 480         {
 481             element->getDocument()->removeChangeListener (this);
 482         }
 483
 484         void setIndex (int newIndex)
 485         {
 486             element->setStretchMode ((StretchMode) newIndex, true);
 487         }
 488
 489         int getIndex() const
 490         {
 491             return (int) element->getStretchMode();
 492         }
 493
 494         void changeListenerCallback (ChangeBroadcaster*)
 495         {
 496             refresh();
 497         }
 498
 499     private:
 500         PaintElementImage* const element;
 501     };
 502
 503     class ResetSizeProperty   : public ButtonPropertyComponent
 504     {
 505     public:
 506         ResetSizeProperty (PaintElementImage* const element_)
 507             : ButtonPropertyComponent ("reset", false),
 508               element (element_)
 509         {
 510         }
 511
 512         void buttonClicked()
 513         {
 514             element->resetToImageSize();
 515         }
 516
 517         const String getButtonText() const          { return "reset to image size"; }
 518
 519     private:
 520         PaintElementImage* const element;
 521     };
 522 };
 523
 524
 525 #endif   // __JUCER_PAINTELEMENTIMAGE_JUCEHEADER__